import java.util.*;

public class Main {
    //乒乓球框
    //https://www.nowcoder.com/questionTerminal/bb4f1a23dbb84fd7b77be1fbe9eaaf32
    public static void main5(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String a = in.next();
            String b = in.next();
            char[] s1 = a.toCharArray();
            char[] s2 = b.toCharArray();
            int[] arr = new int[26];

            //把A盒中的字符转换为数字并且放入到数组中，并且对数组的数进行++
            //这里比如：A盒：ABCDEA -> {2,1,1,1,1}对应A,B,C,D,E
            for (int i = 0;i < s1.length;i++) {
                arr[s1[i] - 'A']++;
            }
            boolean ret = true;
            for(int i = 0;i < s2.length;i++) {
                //对B盒中的字符也转换成数字
                //把转换的数字在数组中进行--，如果小于了0，
                //那么可能是A盒中没有这个字符 或者 B盒中的字符超过了A盒
                if (--arr[s2[i] - 'A'] < 0) {
                    ret = false;
                    break;
                }
            }

            System.out.println((ret ? "Yes" : "No"));
        }
    }

    //LCR 179 查找总价格为目标值的两个商品
    //https://leetcode.cn/problems/he-wei-sde-liang-ge-shu-zi-lcof/
    public int[] twoSum2(int[] price, int target) {
        //有序的，可以使用“双指碰撞”
        //升序，具有单调性，单调递增
        int left = 0,right = price.length - 1;
        while (left < right) {
            int sum = price[left] + price[right];
            if(sum > target) {
                right--;
            }else if (sum < target) {
                left++;
            }else {
                return new int[]{price[left],price[right]};
            }
        }

        return new int[]{-1};
    }

    //整数翻转
    //https://leetcode.cn/problems/reverse-integer/description/
    public int reverse(int x) {
        // x的范围：-2147483648 <= x <= 2147483647
        int ret = 0;
        while(x != 0) {
            //如果是10位数的话，我们所输入的x的第一个数字只能是1或者2，
            //翻转之后会到最后一位，当前9个数字都合法的时候，那么最后一个数字必然是合法的
            if(ret > Integer.MAX_VALUE / 10 || ret < Integer.MIN_VALUE / 10) {
                //就如输入的是 10 为数，这个时候这个最后一位数，只能是1或者是2，因为会翻转到第一位
                //并且进入到这里都是10位数，那么如果大于了1或者2，就溢出了之后要判断翻转之后的9位数
                //是否大于214748364或者小于-214748364,如果是就说明溢出了
                //比如：x = 214748364 3 -> 346384741 2 溢出
                //我们只需要判断 9 位已经翻转的数
                return 0;
            }

            int tmp = x % 10;//取每次的最后一位数字
            ret = ret * 10 + tmp;
            x /= 10;
        }

        return ret;
    }

    //NC41 最长无重复子数组
    //https://www.nowcoder.com/practice/b56799ebfd684fb394bd315e89324fb4?tpId=196&tqId=37149&ru=/exam/oj
    public static int maxLength (int[] arr) {
        // write code here
        //没有使用 哈希表，但是是一个原理
//        int n = arr.length;
//        int[] hash = new int[100000];
//        int right = 0,left = 0;
//        int ret = 0;
//        while(right < n) {
//            //如窗口
//            hash[arr[right]]++;
//            while(hash[arr[right]] > 1) {
//                //说明出现重复数据了，出窗口
//                hash[arr[left]]--;
//                left++;
//            }
//            //更新数据
//            ret = Math.max(ret,right - left + 1);
//            right++;
//        }
//        return ret;
        Set<Integer> set = new HashSet<>();
        int ret = 0;
        int n = arr.length;
        int left = 0,right = 0;
        while (right < n) {
            while (set.contains(arr[right])) {
                //出窗口
                set.remove(arr[left]);
                left++;
            }
            //入窗口
            set.add(arr[right]);
            ret = Math.max(ret,right - left + 1);
            right++;
        }

        return ret;
    }

    //最长回文字符串
    //https://leetcode.cn/problems/longest-palindromic-substring/
    private static int expandAroundCenter(String s,int left,int right) {
        while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return right - left - 1;
    }
    public static String longestPalindrome(String s) {
        int n = s.length();
        int start = 0,lenmax = 1;
        for(int i = 0;i < n;i++) {
            int len1 = expandAroundCenter(s,i,i);//计算奇数的情况
            int len2 = expandAroundCenter(s,i,i + 1);//计算偶数的情况
            int len = Math.max(len1,len2);
            if(len > lenmax) {
                start = i - (len - 1) / 2;
                lenmax = len;
            }

        }

        return s.substring(start,start + lenmax);
    }

    //无重复字符的最长子串
    //https://leetcode.cn/problems/longest-substring-without-repeating-characters/submissions/575750695/
    public static int lengthOfLongestSubstring(String s) {
        HashSet<Character> set = new HashSet<>();
        char[] ss = s.toCharArray();
        int left = 0,right = 0,ret = 0,n = s.length();
        while(right < n) {
            char ch = ss[right];
            while(set.contains(ch)) {
                set.remove(ss[left]);
                left++;
            }
            set.add(ch);
            ret = Math.max(ret,right - left + 1);
            right++;
        }
        return ret;
    }

    //两数之和
    //
    public class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode ret = null,tail = null;
        //我们定义一个存储进制的变量
        int carry = 0;
        while(l1 != null || l2 != null) {
            //如果为空的话，说明没有数据了，就返回0
            int a = l1 != null ? l1.val : 0;
            int b = l2 != null ? l2.val : 0;
            //我们这里是 l1 和 l2 相对的节点和 进制位的值的相加
            int sum = a + b + carry;

            if(tail == null) {
                //说明没有数据，就把ret和tail都放第一个和，假如sum为12我们放入的是 2
                ret = tail = new ListNode(sum % 10);
            }else {
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
            //假如sum = 12 进制就是 1 就是 sum / 10
            carry = sum / 10;

            if(l1 != null) {
                l1 = l1.next;
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }
        //当上面的l1和l2都遍历结束后。carry还不为 0的话，就说明还有一个进位
        if(carry > 0) {
            tail.next = new ListNode(carry);
        }
        //返回头结点
        return ret;
    }

    //两数之和
    //https://leetcode.cn/problems/two-sum/
    public int[] twoSum(int[] nums, int target) {
        //无序，使用暴力枚举 或者是 哈希映射 K——V结构
        //使用 哈希映射的方法
        HashMap<Integer,Integer> map = new HashMap<>();
        int n = nums.length;
        // K—V 的存储，k为数值，v为下标
        for(int i = 0; i < n;i++) {
            //判断 map 中是否存在 target - nums[i] 的值，如果存在，就直接返回这两个的下标
            //如果没有呢，就把 nums[i] 这个值放到 map 中，并且把下标也放里
            if(map.containsKey(target - nums[i])) {
                return new int[]{map.get(target - nums[i]),i};
            }
            map.put(nums[i],i);
        }
        return new int[]{-1};

        //暴力枚举
        //时间复杂度：O(N^2)
        // int n = nums.length;
        // for(int i = 0; i < n;i++) {
        //     for(int j = i + 1;j < n;j++) {
        //         if(nums[i] + nums[j] == target) {
        //             return new int[]{i,j};
        //         }
        //     }
        // }
        // return new int[]{-1};
    }

    //有效三角形的个数
    //https://leetcode.cn/problems/valid-triangle-number/
    public int triangleNumber(int[] nums) {
        //对于判断 三角形是否成立我们只需要判断 三个数中最大值是否小于另外两个数值相加
        //a + b > c（最大值为 c）这个时候就是成立的
        int n = nums.length;
        int ret = 0;
        //先进行排序，因为我们要定最大的数字
        Arrays.sort(nums);

        //从后往前遍历
        for(int i = n - 1; i >= 2;i--) {
            //我们在 i 的后面的区间里取其最大值与最小值
            int left = 0;
            int right = i - 1;
            //定最大值之后，判断其后面的所有区间的值是否可以成立，直至这个区间都判断结束
            while (left < right) {
                if(nums[left] + nums[right] > nums[i]) {
                    //三角形成立
                    //这个时候 right 与 left 的区间就是这个里面可以成立的三角形个数
                    ret += right - left;
                    //成立把 right 后前移，进行值的减小，看是否还会成立
                    right--;
                }else {
                    //不成立，我们把最小值进行增加
                    left++;
                }
            }
        }
        return ret;
    }

    //盛最多的水的容器
    //https://leetcode.cn/problems/container-with-most-water/submissions/575509986/
    public static int maxArea(int[] height) {
        int n = height.length;
        int left = 0;
        int right = n - 1;
        int ret = 0;
        while (left < right) {
            //计算其体积
            int v = Math.min(height[left],height[right]) * (right - left);
            //每次计算出体积之后，我们和 ret 值进行比较取最大值
            ret = Math.max(ret,v);
            if(height[left] < height[right]) {
                left++;
            }else {
                right--;
            }
        }
        return ret;
    }

    //快乐数
    //https://leetcode.cn/problems/happy-number/description/
    private static int func(int n) {
        int ret = 0;
        while(n > 0) {
            int t = n % 10;
            ret += t * t;
            n /= 10;
        }
        return ret;
    }
    public static boolean isHappy(int n) {
        //快慢指针
        //最后是成环，看slow 和 fast 相遇的时候的节点是否是1
        int slow = n,fast = func(n);

        while (slow != fast) {
            slow = func(slow);
            fast = func(func(fast));
        }

        return slow == 1;
    }

    public static void main(String[] args) {
        //boolean s = isHappy(19);
//        int[] arr = {1,8,6,2,5,4,8,3,7};
//        System.out.println(maxArea(arr));
//        String s = "abcabcbb";
//        System.out.println(lengthOfLongestSubstring(s));
        String s = "babad";
        System.out.println(longestPalindrome(s));
    }
    //复写零
    //https://leetcode.cn/problems/duplicate-zeros/
    public void duplicateZeros(int[] arr) {
        int n = arr.length;
        int  cur = 0,dest = -1;
        //找我们要复写的最后一位数字的位置
        while(cur < n) {
            if(arr[cur] == 0) {
                dest += 2;
            }else {
                dest++;
            }
            //先判断 dest 是否在指定位置，后对 cur++，要不然cur 会移位
            if(dest >= n - 1) {
                break;
            }
            cur++;
        }
        //到这cur 就是最后一位要复写的位置
        //我们的 dest 可能是等于 n 的，这时候使用就越界，我们要处理一下
        //出现这种情况下是 cur 这个位置是0而dest出界
        if(dest == n) {
            arr[n - 1] = 0;
            cur--;
            dest -= 2;
        }

        //之后正常从后往前处理结果
        while(cur >= 0) {
            if(arr[cur] == 0) {
                arr[dest--] = 0;
                arr[dest--] = 0;
                cur--;
            }else {
                arr[dest--] = arr[cur--];
            }
        }
    }

    //移动零
    //https://leetcode.cn/problems/move-zeroes/submissions/575231205/
    public void moveZeroes(int[] nums) {
        //双指针
        for(int cur = 0,dest = -1;cur < nums.length;cur++) {
            //判断cur位置是否为0
            if(nums[cur] != 0) {
                int tmp = nums[cur];
                nums[cur] = nums[dest + 1];
                nums[dest + 1] = tmp;
                dest++;
            }
        }
    }

    //牛牛冲钻五
    //https://ac.nowcoder.com/acm/problem/227309
    public static void main1 (String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();

        while(t-- != 0) {
            int ret = 0;
            int n = in.nextInt(),k = in.nextInt();
            char[] s = in.next().toCharArray();
            for (int i = 0;i < n; i++) {
                if (s[i] == 'L') {
                    ret -= 1;
                }else {
                    if (i - 1 >= 0 && i - 2 >= 0 && s[i - 1] == 'W' && s[i - 2] == 'W') {
                        ret += k;
                    }else {
                        ret += 1;
                    }
                }
            }
            System.out.println(ret);
        }
    }
}
